import java.util.Arrays;
import java.util.Stack;

public class MyStack {
    private int[] elem;
    private int usedSize;

    //给一个默认的数组容量
    private static final int DEFAULT_CAPACITY =10;
    public MyStack(){
        this.elem=new int[DEFAULT_CAPACITY];
    }

    //usedSize 可以浅浅的代表下标
    public void push(int val){
        if(usedSize==DEFAULT_CAPACITY){
            Arrays.copyOf(this.elem,2*elem.length);
        }//
        this.elem[usedSize]=val;
        this.usedSize++;
    }
    public int pop(){//删除从来不是拿出来原本的数
        //你在这里，但是那个数据是不可信数据，就不用管他
        //后面在push元素就会把他改掉
        //栈里面有多少个有用的元素其实是由usedSize决定
        if(isEmpty()) {
            throw new EmptyException();
        }
        //我这里逃出来的要求是，我能接受那个值
        int oldVal=elem[usedSize-1];
        usedSize--;
        return oldVal;
    }
    public int peek(){
        if(isEmpty()) {
            throw new EmptyException();
        }
        return elem[usedSize-1];
    }
    public boolean isEmpty(){
        if(usedSize==0){
            return true;
        }
        return false;
    }

}
class Solution2{
    public int evaLRPN(String[] tokens){
        Stack<Integer> stack=new Stack<>();
        for(String s:tokens){
            if(!isOperation(s)){//不是操作数就是数字
                //这时候就是数字
                stack.push(Integer.parseInt(s));
            }else{
                //有可能是操作数的数字之一
                //stack.push(Integer.parseInt(s));
                //字符转数字
                int num1=stack.pop();
                //这是弹出来两个数字
                int num2=stack.pop();
                switch (s){
                    case "+":
                        stack.push(num1+num2);
                        break;
                    case "-":
                        stack.push(num1-num2);

                        break;
                    case "*":
                        stack.push(num1*num2);

                        break;
                    case "/":
                        stack.push(num1/num2);

                        break;
                }
            }
        }
        return stack.pop();
        //想到啥写啥
        //不要总是想一次就把代码写出来
//        这样是不可能的
        //你在
    }
    private boolean isOperation(String s){
        if(s.equals('+')||s.equals('-')||s.equals('*')||s.equals('/')){
            return true;
        }
        return false;
    }

}
class Solution{
    public boolean isValid(String s){
        Stack<Character> stack=new Stack<>();
        for(int i=0;i<s.length();i++){
            char ch=s.charAt(i);//字符串的第一个一定是左括号吗？
            //要是第一个都不是左括号的话，没必要判断了，肯定是不匹配的
            if(ch=='('||ch=='{'||ch=='['){
                //这个时候是左括号
                stack.push(ch);

            }else{
                //这种情况是右括号
                //这个情况其实是去匹配，但若是，直接就栈里面啥也没有嫩 ？
                if(stack.empty()){
                    return false;
                }
                char top=stack.peek();
                //此时top是左括号，ch是右括号
                //看看匹配不匹配
                if (ch==')'&&top=='('||ch==']'&&top==']'||ch=='}'&&top=='{'){
                    stack.pop();
                }else {
                    return false;
                }
            }
        }
        if(!stack.empty()) {
            return false;
        }
        //我喜欢你
        //我是董李阳，你是谁？汪汪汪·
        //我喜欢你你是谁
        return true;
    }


    
}
